package com.teacher.game.model;

import android.graphics.Rect;
import com.teacher.ellio.Assets;
import com.teacher.ellio.GameMainActivity;
import com.teacher.game.framework.animation.Animation;
import com.teacher.game.framework.util.Painter;

/**
 * 玩家角色类 - 实现跑酷游戏中的主角控制
 * 功能：跑步、跳跃、下蹲动作，物理引擎，碰撞检测
 */
public class Player {
    
    // 物理常量
    private static final float GRAVITY = 1000f;        // 重力加速度 (像素/秒²)
    private static final float JUMP_VELOCITY = -500f;  // 跳跃初始速度 (像素/秒)
    private static final float GROUND_Y = 400f;        // 地面Y坐标 (真正站在草地上)
    private static final int PLAYER_WIDTH = 64;        // 角色宽度
    private static final int PLAYER_HEIGHT = 64;       // 角色高度
    
    // 状态常量
    public static final int STATE_RUNNING = 0;   // 跑步状态
    public static final int STATE_JUMPING = 1;   // 跳跃状态  
    public static final int STATE_DUCKING = 2;   // 下蹲状态
    
    // 双跳系统
    private boolean canDoubleJump = true;        // 是否可以双跳
    private int jumpCount = 0;                   // 当前跳跃次数
    private static final int MAX_JUMPS = 2;      // 最大跳跃次数（双跳）
    
    // 核心属性
    private float x, y;              // 位置坐标
    private float velocityY;         // Y方向速度
    private int currentState;        // 当前状态
    private boolean isJumping;       // 是否在跳跃中
    private boolean isDucking;       // 是否在下蹲中
    
    // 动画相关
    private Animation runAnimation;   // 跑步动画
    private Animation jumpAnimation;  // 跳跃动画 (单帧)
    private Animation duckAnimation;  // 下蹲动画 (单帧)
    private Animation currentAnimation; // 当前播放的动画
    
    // 道具效果系统
    private boolean hasShield = false;           // 是否拥有护盾
    private float shieldDuration = 0;            // 护盾持续时间
    private boolean doubleScoreActive = false;   // 双倍得分是否激活
    private float doubleScoreDuration = 0;       // 双倍得分持续时间
    private boolean slowTimeActive = false;      // 时间减缓是否激活
    private float slowTimeDuration = 0;          // 时间减缓持续时间
    
    // 计时器
    private float duckTimer;         // 下蹲计时器
    private static final float DUCK_DURATION = 1.0f; // 下蹲持续时间（符合用户故事要求约1秒）
    
    /**
     * 构造函数 - 初始化玩家角色
     * @param startX 起始X坐标
     * @param startY 起始Y坐标
     */
    public Player(float startX, float startY) {
        this.x = startX;
        this.y = startY;
        this.velocityY = 0;
        this.currentState = STATE_RUNNING;
        this.isJumping = false;
        this.isDucking = false;
        this.duckTimer = 0;
        
        // 初始化动画
        initAnimations();
        this.currentAnimation = runAnimation;
    }
    
    /**
     * 初始化角色动画
     */
    private void initAnimations() {
        // 跑步动画使用现有的runAnim
        this.runAnimation = Assets.runAnim;
        
        // 跳跃动画 (单帧)
        this.jumpAnimation = Assets.jumpAnim;
        
        // 下蹲动画 (单帧)  
        this.duckAnimation = Assets.duckAnim;
    }
    
    /**
     * 跳跃动作（支持双跳）
     */
    public void jump() {
        // 检查是否可以跳跃（支持双跳）
        if (jumpCount < MAX_JUMPS && canDoubleJump) {
            velocityY = JUMP_VELOCITY;
            jumpCount++;
            
            // 第一次跳跃设置为跳跃状态
            if (jumpCount == 1) {
                isJumping = true;
                isDucking = false; // 跳跃时取消下蹲状态
                duckTimer = 0;     // 重置下蹲计时器
                currentState = STATE_JUMPING;
                currentAnimation = jumpAnimation;
            }
            
            // 播放跳跃音效
            Assets.playSound(Assets.jumpSoundId);
        }
    }
    
    /**
     * 下蹲动作
     */
    public void duck() {
        // 只在地面上才能下蹲
        if (!isJumping) {
            isDucking = true;
            currentState = STATE_DUCKING;
            currentAnimation = duckAnimation;
            duckTimer = DUCK_DURATION;
        }
    }
    
    /**
     * 更新玩家状态 - 每帧调用
     * @param delta 时间增量 (秒)
     */
    public void update(float delta) {
        // 更新当前动画
        currentAnimation.update(delta);
        
        // 处理跳跃物理
        if (isJumping) {
            // 应用重力
            velocityY += GRAVITY * delta;
            y += velocityY * delta;
            
            // 着地检测
            if (y >= GROUND_Y) {
                y = GROUND_Y;
                isJumping = false;
                velocityY = 0;
                jumpCount = 0; // 重置跳跃次数，允许下次双跳
                
                // 回到跑步状态
                if (!isDucking) {
                    currentState = STATE_RUNNING;
                    currentAnimation = runAnimation;
                }
            }
        }
        
        // 处理下蹲计时
        if (isDucking) {
            duckTimer -= delta;
            if (duckTimer <= 0) {
                isDucking = false;
                
                // 回到跑步状态 (如果不在跳跃中)
                if (!isJumping) {
                    currentState = STATE_RUNNING;
                    currentAnimation = runAnimation;
                }
            }
        }
        
        // 更新道具效果
        updatePowerUpEffects(delta);
    }
    
    /**
     * 更新道具效果
     */
    private void updatePowerUpEffects(float delta) {
        // 更新护盾效果
        if (hasShield) {
            shieldDuration -= delta;
            if (shieldDuration <= 0) {
                hasShield = false;
                shieldDuration = 0;
            }
        }
        
        // 更新双倍得分效果
        if (doubleScoreActive) {
            doubleScoreDuration -= delta;
            if (doubleScoreDuration <= 0) {
                doubleScoreActive = false;
                doubleScoreDuration = 0;
            }
        }
        
        // 更新时间减缓效果
        if (slowTimeActive) {
            slowTimeDuration -= delta;
            if (slowTimeDuration <= 0) {
                slowTimeActive = false;
                slowTimeDuration = 0;
            }
        }
    }
    
    /**
     * 渲染玩家角色
     * @param g 绘制工具
     */
    public void render(Painter g) {
        int renderY = (int)y;
        
        // 下蹲时调整渲染位置
        if (currentState == STATE_DUCKING) {
            renderY += 20; // 下蹲时角色位置下移
        }
        
        // 渲染当前动画帧
        currentAnimation.render(g, (int)x, renderY);
        
        // 渲染护盾效果
        if (hasShield) {
            renderShieldEffect(g, (int)x, renderY);
        }
    }
    
    /**
     * 渲染护盾效果
     */
    private void renderShieldEffect(Painter g, int x, int y) {
        // 蓝色半透明护盾圆环
        g.setColor(android.graphics.Color.argb(100, 0, 150, 255));
        int shieldRadius = 40;
        g.fillOval(x - 10, y - 10, PLAYER_WIDTH + 20, PLAYER_HEIGHT + 20);
        
        // 护盾边框
        g.setColor(android.graphics.Color.BLUE);
        // 简化的边框绘制
        int borderThickness = 2;
        g.fillOval(x - 12, y - 12, PLAYER_WIDTH + 24, borderThickness); // 上
        g.fillOval(x - 12, y + PLAYER_HEIGHT + 10, PLAYER_WIDTH + 24, borderThickness); // 下
        g.fillOval(x - 12, y - 12, borderThickness, PLAYER_HEIGHT + 24); // 左
        g.fillOval(x + PLAYER_WIDTH + 10, y - 12, borderThickness, PLAYER_HEIGHT + 24); // 右
    }
    
    /**
     * 获取碰撞矩形 - 用于碰撞检测
     * @return 角色的碰撞盒
     */
    public Rect getCollisionRect() {
        int width = PLAYER_WIDTH;
        int height = PLAYER_HEIGHT;
        
        // 下蹲时调整碰撞盒
        if (currentState == STATE_DUCKING) {
            height = PLAYER_HEIGHT / 2; // 下蹲时高度减半
        }
        
        return new Rect(
            (int)x, 
            (int)y, 
            (int)x + width, 
            (int)y + height
        );
    }
    
    // Getter方法
    public float getX() { return x; }
    public float getY() { return y; }
    public int getCurrentState() { return currentState; }
    public boolean isJumping() { return isJumping; }
    public boolean isDucking() { return isDucking; }
    public int getWidth() { return PLAYER_WIDTH; }
    public int getHeight() { return PLAYER_HEIGHT; }
    
    // Setter方法 (用于调试和特殊情况)
    public void setPosition(float x, float y) {
        this.x = x;
        this.y = y;
    }
    
    /**
     * 重置玩家状态 - 用于游戏重新开始
     */
    public void reset() {
        this.x = 100; // 重置到起始位置
        this.y = GROUND_Y;
        this.velocityY = 0;
        this.isJumping = false;
        this.isDucking = false;
        this.duckTimer = 0;
        this.currentState = STATE_RUNNING;
        this.currentAnimation = runAnimation;
    }
    
    /**
     * 获取地面Y坐标常量
     * @return 地面Y坐标
     */
    public static float getGroundY() {
        return GROUND_Y;
    }
    
    // ========== 道具效果激活方法 ==========
    
    /**
     * 激活护盾效果
     * @param duration 持续时间（秒）
     */
    public void activateShield(float duration) {
        this.hasShield = true;
        this.shieldDuration = duration;
    }
    
    /**
     * 激活双倍得分效果
     * @param duration 持续时间（秒）
     */
    public void activateDoubleScore(float duration) {
        this.doubleScoreActive = true;
        this.doubleScoreDuration = duration;
    }
    
    /**
     * 激活时间减缓效果
     * @param duration 持续时间（秒）
     */
    public void activateSlowTime(float duration) {
        this.slowTimeActive = true;
        this.slowTimeDuration = duration;
    }
    
    /**
     * 检查是否有护盾保护
     */
    public boolean hasShieldProtection() {
        return hasShield;
    }
    
    /**
     * 消耗护盾（碰撞时调用）
     */
    public boolean consumeShield() {
        if (hasShield) {
            hasShield = false;
            shieldDuration = 0;
            return true; // 护盾成功阻挡了伤害
        }
        return false; // 没有护盾
    }
    
    /**
     * 检查双倍得分是否激活
     */
    public boolean isDoubleScoreActive() {
        return doubleScoreActive;
    }
    
    /**
     * 检查时间减缓是否激活
     */
    public boolean isSlowTimeActive() {
        return slowTimeActive;
    }
    
    /**
     * 获取剩余护盾时间
     */
    public float getShieldDuration() {
        return shieldDuration;
    }
    
    /**
     * 获取剩余双倍得分时间
     */
    public float getDoubleScoreDuration() {
        return doubleScoreDuration;
    }
    
    /**
     * 获取剩余时间减缓时间
     */
    public float getSlowTimeDuration() {
        return slowTimeDuration;
    }
}